Structure and Interpretation of Computer Programs [Later Printing]

I fall between the polarized views of the reviewers of this textbook. This is a well-written introduction to Lisp programming and Scheme, and introduces many important concepts in Computer Science. The problem with it is that it is not a suitable book for a beginner -- I don't consider it a gentle introduction to computer science -- and for someone experienced enough to be comfortable with its ideas, it doesn't introduce many interesting ideas until Chapter 3. Unlike other people I guess, I found the reading sometimes difficult, but interesting and comprehensible. I didn't learn much of anything (except Scheme) until the Brandeis course I took reached the discussion of the environmental model of evaluation. But from there on I learned some interesting ideas, especially about the interpretation of computer programs, non-deterministic programming, and logic. Unfortunately we didn't get to the last chapter on compilation, but I might look at that this summer. At Brandeis University, this is the second course in the major, not counting two optional intro courses which are designed for non-majors and people with little background who want to be majors. But even with the interesting ideas, it was mainly Lisp that I learned, which I don't consider a waste of time by any means.

This book explains every concept about programming languages, thus, it can represent every single compiler there is out there. Most people who gave a rating of 1 star just wants a solution to the problem. They want to have a working function without fully understanding the components of the function and what it actually does.

Read this book if you want to understand the difference between "coding" and "software engineering". Read it if you believe that, in order to master the craft of computer programming, it is necessary first to understand the principles that underly how we use computers to automate reasoning. Do not read this book if you just wanna "write code". Such readers will not understand the book, and it will just frustrate them. Instead, read any one of the many books with titles like "Teach Yourself C++ in 21 Days".
And judging by some of what the negative reviewers have said ("scheme doesn't have iteration, just recursion", and "just a lot of theory", and "learn a more common language like C++") if you do not understand this book, do not ask me for a job. Instead, go on believing that today's most fashionable language is superior to all others and that learning syntax is the most important thing you can do.
This is a challenging book. It is not a cook-book of algorithms, and it does not contain one example that people who advocate practice over theory would label "real world". Instead, it gives readers the mental tools to create algorithms when the cook-book is inadequate.
But it ain't perfect. With the exception of one small example, the book does not go into the compromises that digital computers make (precision in floating point math, for example).

SICP is an excellent, perhaps the best, advanced introduction to computer science and programming. It covers topics such as functional abstraction, data abstraction, OOP, program design, constraint programming and logic programming, always from a language design point of view. You will need a decent mathematical background to follow it.
If it's such a great textbook, then why half of the reviewers hate it? Elementary: SICP is not just a textbook, it's also a Computer Science aptitude and vocational test. If you read it and like it, then Congratulations! You are a real programmer and computer scientist, with hair on your chest. If you don't like it, then you should be studying something else. Law, mortuary science, whatever, but not CS.

This is a classic book. It's a challenging book, and I mean that in the best possible way. If you want a simple breezy book that doesn't make you think hard, this is not the book for you. If you want to rapidly understand more sophisticated topics, this is a very good book.

Frankly, I'm appalled at the elitists comments made by many of the 5-star reviewers. It's that very superior attitude which prevents the comp-sci field from creating more scientists rather than code monkeys and justifies poor pedagogy and technical writing for the sake of "scientific integrity."

SICP is neither masterpiece nor pariah. No other introduction to computer science has a truer grasp of the "soul" of computer science. Not only that, but there is ALOT of useful theory in here, if you have the patience to look.

But, the book suffers for dreadful writing and advocacy of a language that can be really quite a horror for beginning programmers. On one hand, the authors took an approach that should have been brilliantly successful. On the other, they did a terrible job explaining fairly simple ideas (or, rather, ideas that should have been simple.)

But, the truth is SICP has SO MUCH to offer. Unfortunatedly, the book is only as educational as the CS professor who teaches it. It turns out that the Berkeley professor who said that SICP is "the greatest CS book ever written" is the finest CS teacher at Berkeley. Unfortunatedly, most CS professors are not even 1/10th as good as he is and therefore help make SICP a tortorous excursion.

As a EECS major at Berkeley, I've come to realize just how important theory is in the field of CS. And to that end, I think it is as easily critical that theory should be taught with the utmost respect, not only for the field but the students. SICP is a brilliant master, but often a contemptuous teacher.

Great computer science book overall. I really wish I had read this years ago. This book gave me a lot of insight into concepts that I thought I already knew.

There are some bad reviews here on the store which are a little hard for me to understand. I can certainly see how this book isn't for everyone - it requires a certain way of looking at things. But then, computer science itself requires that same way of looking at things. If you think Java is a great language for teaching computer science, you won't like this book. But please reconsider your career choice. (And I can't help but address the assertion in one of the reviews that "virtually every conventional algorithm is NOT implementable in scheme". Obviously this is completely and laughably false, but I would absolutely love to know what the reviewer was thinking - how could someone get such a ridiculous idea in his head?)

I do have a few problems with the book. Firstly, the book fairly often describes a few procedures to you, and then wants you to complete exercises using the procedures. But you have no actual implementation of the procedures, and thus you cannot run any of the code you are writing (sometimes hundreds of lines). Frankly, this sucks. One of the great things about computer science is that you get immediate feedback when you code. You write it, run it, bam, there's your result. In most cases, the book does eventually give you the implementations for the missing procedures, but in at least one case, it does not.

Another problem with the book is that it does not provide answers for the exercises. This is unfortunately a common situation, not just in computer science. This is probably OK in a classroom setting, but what about us autodidacts? I'm not sure of the answer to a few of the open-ended questions in this book and there's basically no way for me to find the answer.

Lastly, considering the book is supposedly an "introductory" computer science textbook, it's too bad it's not quite suitable for someone who is smart but who has no programming experience to just pick up and use directly. There are too many peripheral issues not addressed for such a person.

I do consider these serious problems. The fact that I'm still giving the book 5 stars shows how good I think it is despite these issues.

I've been a professional in the computer science industry for years, and I still find new gems, leading to ah-hah! moments, each time I pick this book up. Saying that I underappreciated this book when I first read it is an understatement. Based on many of the reviews here, I suspect this is a common phenomenon. Those who care deeply about computer science love this book; those who see this book as the only barrier between them and a passing score in their current CS course clearly do not.

This book teaches you to think about problems in a different way, a way which stays with you forever. I guess LISP is like that in general. The mechanics and specific techniques are not as important as comprehending the entire material at a higher level.

Read it once, read it twice...heck, read it once a week from now until you die. I plan to.

I'm assuming this book is intended for beginners, since those who are advanced will only be wasting their time reading this childish text.
If you're a beginner, starting to learn programming by reading this book is like discussing the next major physics theory without know any physics. You'll learn to philosophize and throw around grand but meaningless ideas. Starting with C and machine organization books (i.e. assembler) is a better way. You'll learn the internals first, find out what's behind programming. You'll know how procedures are actually called, and what some of the issues are. Than you can read books like these. In fact, towards the end of chapter 4, the authors themselves admit that their simplistic view of computers and languages is severely deficient if they want to descirbe things properly, so in ch.5 they introduce register machines (i.e..they teach you abou how CPUs work). Beginners learning from this text is akin to space scientits planning a complex trajectory, and than getting down to learn basic Newtonian mechanics. No wonder so many beginners I've talked with complained. They couldn't understand what all of this encapsulation meant, since they had no idea of the basic underlying process--simple pushes onto a stack and jmp instructions.
Aside from the book's wrong approach, it's also terribly written. I tired to like it, but books can only be so boring before you start to feel aversion towards it.

I was hoping, based on the comments of some people, that this book would be somewhat of a bible for programming...they said it's the best book of programming ever written. I was quite disappointed. One of three things usually happened when I read about a new topic in this text:
1. I already knew some things this book talks about. They are, in fact, fairly obvious, like abstraction.
2. The idea was fairly interesting, but it wasn't possible to implement it outside of Scheme. In other words, this idea became useless.
3. Some things were just a pointless waste of time. Purely philosophical discussions.
In short, this book told me nothing new. A huge disappointment. I don't understand what these people see in it.

If you disagree, hopefully you're thinking Knuth. But consider this: Knuth is a wonderful bestiary of important programs and proofs; SICP is about the very nature of programming and programs.

If you're not thinking either, and no offense to K&R et al: Do yourself a favor, watch the videos. Sussman & Abelson are entertaining teachers. SICP is a difficult book, and seeing Sussman in a fez after the metacircular evaluator just... helps.

But of course Graham's and Norvig's reviews are gems of their own.

The negative reviewers entirely missed the point of this book. The issues are not c++ versus scheme, nor the gap between the book's examples and real-world programs, nor that recursion is less intuitive than looping.
The real point is to teach some very core foundations of computer science that show up everywhere. For example, supposedly revolutionary XML looks a heck of a lot like a nested scheme list, first described in 1960. And processing an active server page (or Java server page) is very much like the textbook's specialized language evaluator. Finally, c++ polymorphism through vtables and part of Microsoft's COM mechanics are the exact same thing as the book's data-directed programming section.
This is very deep material for a programming newbie to learn outside a course, but for an experienced nerd who's looking for a systematic framework, it's absolutely terrific. I had done lots of lisp and compiler work before reading the book, so many of the concepts were not new. But it's with this framework in mind that I learn new technologies, and this approach greatly speeds up how long it takes to understand each week's "new" hot product/language/tool/mindset. Put another way: why do so many popular computer books take 1000 pages to describe a few trivial concepts?

The 1 star reviews show what is wrong with education in general and computer science specifically. They give credence to Spolsky's conjecture about Java schools.

Computer science is a mathematical discipline, people complaining about math do not belong in this field. People who claim that certain algorithms can not be implemented in Scheme need to either start paying attention in class, or switch to a business program.

This is a freshman level textbook. The theories in this book are not arcane nor irrelevant. They are what is necessary to truly understand computation. That so many people think otherwise is not surprising given how terrible the vast majority of software is these days.

This book is well-written and engaging. It gets to the point and gives great examples in a language that everyone should learn. If more people understood lispy languages and functional language concepts it would be much easier to find competent programmers, even if they are being hired for projects that use clunky languages like C, C++, Java or C#.

In short, the concepts in this book separate the CS professionals from the API monkey.

I originaly was introduced to this book in college by a teacher who said the text would open heretofore unknown vistas to me. It was supposed to turn me into a deeply understanding computer scientist, and not just a code monkey. I found out those promises didn't come true. Two semesters later I was feeling lucky to have finally finished the course, and was angry to have wasted so much time. This book quite simply doesn't deliver what it promises. Instead, it tries to be as coprehensive as possible, covering so many topics that I was dizzy, but it does a very bad job of explaining anything in detail. The end result is that I learned nothing. Apparently the authors believe quantity is better than quality. In any case, you won't get anything out of that text...and it certainly won't make you a better computer scientist, though it pretends to. Don't waste your time and money.

This book is to Computer Science what the Feynman Lecture notes are to physics: an introductory text that could reshape the mind of the average PdD. It's not about Lisp, it's not about Scheme, it's about computing at the most fundamental levels. If you're an experienced programmer, it will change your way of thinking forever. If you're a novice, it will set you down the right path. Read it and work through every problem. Repeat every few years.

The best textbook ever written to teach computer programming to college freshmen, though somewhat difficult for the non-mathematically minded. Exposes the basics of programming in a clear, elegant way, starting from simple procedural and structural abstraction up to virtual machine, interpreter and compiler design, through object, concurrent or logical oriented ways of programming. Exercises are rather stimulating, and actually doing them is more than half the substance of the book: it's not a book one merely reads, it's a books one does. Although intended for students of Computer Science, this course should appeal students of all engineering branches, because the principles taught are not only relevant to the art of computer programming, but also to the design of all kinds of complex systems. If you need only one introductory book about the subject, try this one.

SICP takes you to the heart of Computer Science. It teaches you to be a computer scientist, not a programmer.

This is a book that you read in your spare time, not when your have a project due in two weeks (or a final tomorrow). It is more philosophical than practical, and is for the aspiring computer scientists rather than those who need to get out there to make some money and buy stocks.

And it is quite advanced in theory for an introductory text. Beginners are better off with books that approach these ideas from a practical programming perspective.

Structure and Interpretation of Computer Programs (SICP) is one of the best book on computer science.I've here found a well number of peoples who have rated the book as 1 but I can't understand why? Actually those people either thinks computer science and mathematics are different or they need some spoon feedings on the subject.Computer science(as the book suggest) is the field of Imperative Knowledge and Mathematics is the field of Declarative as well as Imperative knowledge.Now why you need Math in Computer Science? That's because, suppose you have designed some algorithms or data structures or a new computational model, but how can you prove that the designed Imperative Knowledge is true or false? Then you need Declarative Knowledge i.e. Mathematics and for this reason only every field of science and engineering requires a very firm grasp in mathematics.This book is not for mere programmers or casual computer science student, this book is for Computer Scientist or for the students whose aim is to become a serious computer scientist/engineer.And lastly to understand this book you should be very sharp at mathematics,at least to first order logic and always keep in mind mathematics is an inherent part of computer science and this is the only reason that most of computer scientist till to date have conventional degree in mathematics including Dennis Ritchie the creator of C language and there are some beautiful books as "Concrete Mathematics" and "Algorithms" by Donald E Knuth[have degree in math] and "Introduction to Algorithms" by Coreman et all[all those respected MIT professors have degree in Math].

The book promises to make a better programmer out of you, to teach you how to think about programs, but this promise is not kept. Those things which it presents that are relevant to overall philosophy of programming are already widely know as it is. The other things they present are completely useless. In short, you will not gain any valuable insight and won't see any revelations or any radical and vastly superior methods of thinking about programs. It's just mundane drivel here. To top it off, the book is very dry. I'm extremely interested in theoretical computer science and this book managed to bore even me. You'd need a lots and lots of patience to get through even a fraction of the material here. I wouldn't recommend this title to anyone.

Regardless of what you think is useful computer knowledge, this book does a bad job of presenting its topics. Especially for beginners, this book is very frustrating. The first few chapters often employ obscure mathematical tricks as examples of how the computing concepts can be applied. In the end, the reader doesn't see the forest for the trees and tries to figure out the math just to understand what the code samples are doing. Other parts of the book either mention in passing, or devote very little space to interesting ideas, and instead devote pages and pages to something fundamental, to the point that it gets very boring. Finally, I personally think this book is poorly organized. The first four chapters try to focus on maximum abstraction, and the last chapter presents a totally oposing view of computers--as register machines...which is a completely different paradigm. This confuses many people.
I'd give this book zero stars if I could.

If you read books carefully and try to understand their meaning, you'll be frustrated by this text.
If you read 'popular' books as a 'trophy' collection activity and don't think about content...this book is for you. It's from MIT..all the prestige you need in one little text...who cares about the actual conent?
Those who do care, stay away. Some of the most fundamentally important material is gathered here and butchered in the most horrific way. I suggest you look at specific books on topics such as hardware design, compilers, etc...this book will only cause pain and won't explain them.

It's amazing how polarized the opinions on this book are. I personally consider it a landmark book, but that's almost irrelevant given the controversy created by the reviews I've seen here.
I've read this book when I was already an experienced programmer and I can say it was truly inspirational. I can imagine it can scare beginners, or render the snooty ones angry.
I think the best way to figure out what *you* would think of the book is to take a look at it yourself. This is now easy because the full text is now online - you can find it easily by searching "sicp" with google. The current address is mitpress dot mit dot edu slash sicp.

I have almost finished reading this book. it is difficult, isn't it ? Seriouly, it is an engineer-oriented book - many example/application to use the scheme, but no theory. Maybe, the auhtor wanted you to learn the scheme language, just exactly like the way you learn the natural language. But, there is really easier mathematical way to learn the computer languages, more clearly, quickly, efficiently. I strongly recommend that you read McCarthy's paper "Recursive Functions of Symbolic Expressions" before diving into this book, which is much rewardable. Scheme is small, while powerful, because it is based on the solid mathematical foundations.

I have very mixed emotions about this book. On the one hand, it is perhaps the best introductory work on the philosophical and theorectical issues of computation, dealing with many concepts that normally are either taken for granted by most programmers, or else are completely unknown to them. If you get past the dry, analytical tone (and the rather flat punnery), it actually becomes quite engaging. It is a book that demands careful thought on the part of the reader, and can reward dilligent and thoughtful study. It scrutinizes even such seeming obvious concepts as recursion and assignment, and often reveals a great deal of hidden complexity to them.
However, by itself it is not a very good primer to progamming, either in theory or in practice. The examples given are often unnecessarily tortuous, especially given the imperative to teach strict functional design in the first several chapters. Too much effort has been given to keeping it at 'pure' and 'general', and there is little attempt to connect the important ideas with how they appear in actual use.
Among the flaws is too great a concern with language independence, and specifically, an obsession with presenting the fewest possible language constructs needed to achieve a given purpose. It makes no attempt to present the Scheme language itself except where it is absolutely necessary in order to give an example; while this is done to keep the discussion as general as possible, it often has the effect of confusing the student. Many example programs which would be crystal clear with the use of certain language facilities are made hopelessly incoherent because the authors wanted to enforce 'language independence'.
Also, because many aspects of the language are ignored as irrelevant, the students learn only a small part of the language itself, and are left with the impression that Scheme is a hamstrung, pedantic language lacking in many obvious features. From reading SICP, few would ever imagine that it supported strings, characters and vectors, or had an iterative construct (do), an escape mechanism (call/cc), a macro facility (let-syntax and syntax-rules), or even basic stream I/O (read and write). Scheme is a simple enough language as it is; it need not be pared down any further no matter how noble the purpose.
More importantly, much of the presentation so abstracted as to be completely divorced from real practice, especially in the sections on imperative and OO programming. While this is a good thing in many ways, as it shows the conceptual underpinnings which are so often lost in day-to-day programming, no attempt is made to draw a connection between the theoretical abstractions and the concrete practices. The ideas are left floating aimlessly, and the student is left with no clue as to their relevance or value - which is a pity, because they truly are important, and understanding them can make the difference between a true programmer and a mere coder.
The section on logic databases is an excellent example of this. While it presents all the elements of keys, querying, unification, etc. in a lucid, detailed fashion, the databases are represented solely as list structures. No mention of files is made at all, in this section or anywhere else in the book - the word 'file' does not even appear in the index. Nor does it reveal that most database work today is based on the relational calculus, not predicate logic.
Similarly, the discussion of streams concentrates solely on their use as a way of representing change in state over time; not only are ports (Scheme's stream I/O mechanism) ignored, at no point is the student given any hint at all that the primary use of streams is for input and output. This is like discussing driving without ever admitting the existence of roads; it is abstraction run rampant. While the discussions are wondefully insightful, the student isn't given any way to apply them, even within the context of study.
In the end, I would strongly recommend this book as a supplement to an introductory course based around another Scheme text, such as Simply Scheme. While I think that every serious student of computer science (as independent from software engineering) should study it, really requires the work of a gifted teacher to make it clear, and it should never be used as the sole text. It is a brillant piece of work, and a wonderful source of key insights into programming, but it does not stand alone.

As is probably obvious from the sharply divided ratings, this book doesn't appeal to everybody. For me, it deserves the full five stars. This was the *only* textbook I kept from college. My leanings are more toward the theoretical, and I'm more interested in conceptual books (like the GOF patterns book) than implementation books (like, say, K&R). I think that this is a reasonable guideline for evaluating whether or not this book is worth reading... So, I give this book five stars in terms of a theoretically oriented read, and maybe two stars in terms of a practically oriented read.

If you read books carefully and try to understand their meaning, you'll be frustrated by this text.
If you read 'popular' books as a 'trophy' collection activity and don't think about content...this book is for you. It's from MIT..all the prestige you need in one little text...who cares about the actual conent?
Those who do care, stay away. Some of the most fundamentally important material is gathered here and butchered in the most horrific way. I suggest you look at specific books on topics such as hardware design, compilers, etc...this book will only cause pain and won't explain them.

I never heard so many interesting and different views expressed for any book.some call it a waste of time and others a classic.Some refer it as an apptitude test for comp sc and others a book that has nothing to do with modern software engineering.
I think everyone is right at its own place. It all depends on how you look at things.Their is a set of inquistive ppl in the world who wants to know why and how of every thing .. why this apple is falling towards the ground and not the otherway .. isn't this a stupid question, a lil crazy for Newton to think this way so is this book.
The author starts by exploring what a program is. what is data,procedure,abstraction,modularity what we can do with it .how to model systems and why ? well all these are trivial questions and why do we care..we are living in a world of MFC's,API's,Integrated Environments..True thats why this book is a waste of time and has got nothing to do with modern software engineering.
But if you care why the apple is falling towards the ground and if you have the faculty to wonder you are going to like this book. It will give u insight in to the programing will make u think in terms of programming and not languages.. may be will add to ur creativity..This book is not easy to read.I think this book is equally difficult for a fresher and a 10 yrs exp guy.It all depends on how gifted u are. if u have it, it doesn't matter how many years u have put in to comp sc.
If you want to make an apple pie from scratch, you must first create the universe.SICP is all about this.

I must say, it takes great talent to take relatively simple and curious ideas, and present them in a very boring and convoluted way. That's right, this book will make you feel pain at every paragraph. You won't learn anything either. If you are interested in theoretical side of computers, there are plenty of better books. Don't waste your time and money on this one.

I would say only the idea of abstraction is "beatiful" but the rest of the book is drivel. It tries to present profound ideas, but fails miserably for lack of lively content or perhaps the incompetence of the authors as teachers. Although I haven't looked, I'm sure there are plenty of better books on the art of programming. This one is just a waste of time no matter what your interests are.

i bought this after wanting to brush up on theory, algorithms, programming concepts and all the other Compsci stuff but didn't want to go back to skool.

this book really helps brush up on what you need to know and I would recommend that anyone taking compsci today get this book and work thru it in conjunction with your regular classes.

those of you who didn't go to compsci should get this book too.
You will learn a lot..but not how to spel!

This is one of the great classics of computer science. I bought my first copy 15 years ago, and I still don't feel I have learned everything the book has to teach.
I have learned enough to write a couple books on Lisp that (currently) have four to five stars. Yet SICP, which is pretty much the bible of our world, has only three? How can this be?
Reading the reviews made it clear what happened. An optimistic professor somewhere has been feeding SICP to undergrads who are not ready for it. But it is encouraging to see how many thoughtful people have come forward to defend the book.
Let's see if we can put this in terms that the undergrads will understand -- a problem set:
1. Kenneth Clark said that if a lot of smart people have liked something that you don't, you should try and figure out what they saw in it. List 10 qualities that SICP's defenders have claimed for it.
2. How is the intention of SICP different from that of Knuth? Kernighan & Ritchie? An algorithms textbook?
3. Does any other book fulfill this purpose better?
4. What other programming books first published in the mid 1980s are still relevant today?
5. Could the concepts in this book have been presented any better in a language other than Scheme?
6. Who is al? Why is his name in lowercase?

My CS professor at UC Berkeley, introduced his course as the best CS course at Berkeley because it uses the "greatest CS book ever written." For all the pain and long hours it has put me through, I must admit this book taught me concepts I never knew. This book is not for the casual reader who wants to learn practical programming, but rather for someone who wants to really be hit hard by all the important topics in Computer Science today. Good luck!

Everyday, my friends would talk about this book and remind each other to read their fare share of SICP for the day.
I finally saved enough money to buy my own copy, and I'm now making sure I read a few pages a day.

Best wizard book ever, as Sussman would put it

I was quite disappointed with this book. It starts out ok, but after the second half of section 2, the book gets to be incredibly thick and boring. I've never felt so disinterested about anything in computer science, and it's not the subjects, mind you (compilers and logic programming can be fun), but it's the dry, pedantic style, obviously written for the sake and glory of the authors and not for the sole purpose of teaching someone.

...but only if you skim it quickly, brainwash yourself into thinking you learned a lot, and glorify this book because of its prestigious MIT roots.
If you are one of those who think deep about the things you read, you'll realize most of this book doesn't make any sense. I learned the material from my college professor. (who hates the book, btw.)

Unless you are required to have this text for the course (and why else would you buy this terrible book?) don't get the text. If you have any doubts about computer science, this book will make you hate it. It tries to mold budding computer scientists by gathering the driest, most boring subjects into one monster collection. You'll probably fall asleep before finishing the first few pages.

This has got to be the worst, most boring computer book I've ever read. The authors managed to gather the dullest material possible and present it in a very lifeless way. I had to get this book for the course (also very boring) and threw it away afterwards because no one would buy it back from me. If you love this book...you'll probably make a great hypnotist...so would the authors.

Typeset in LaTeX. A classic. Accessible to whomever is serious about Computer Science. A great introduction to the Lisp family of funcional languages, in its modern incarnation: Scheme. What is there not to like? Nothing.

Typeset in LaTeX. A classic. Accessible to whomever is serious about Computer Science. A great introduction to the Lisp family of funcional languages, in its modern incarnation: Scheme. What is there not to like? Nothing.

The book never lives up to all the hype surrounding it. In fact, of the over 50 people I know who had the misfortune to study out of it, none liked it. I imagine only a few crazy souls who care about nothing but dry computer langague theory would even consider this worth reading.
Recursion and information hiding via procedural/object code is nothing mysterious and is taught in all other CS classes, so the text adds nothing new. It merely retells the same old obvious programming techniques using a very poorly designed language (Scheme) and using completely uneducational examples. In short, this book is an overrated waste of time. If you are familiar with structured programming in a langauge like C++, you won't get anything new out of this. In fact, any topic presented here is better learned elsewhere, since the text is just one of those poorly written books that try to be encyclopedic at the expense of being interesting and thorough.

If you design computer systems, you will love this book. If you whack away until your program does what you want, you will think it's stupid.
There are sheep, and there are goats. The goats think they are pretty much the same as the sheep. They are not.

i am a UCberkeley Electrical Engineering and Comp sci major... a person that would much rather be out "swing" dancing or hiking...however this book was so intriguing that i needed to dedicate my weekends learning philosphy of computer science(versus computer programming)... I loved it..the time passed by... the exercises were fun and interesting...the reading was hard, but its a rewarding path! This book definitely helps you condition your ability to define problems and solve them :-)

Scheme is a great language for writing Scheme interpreters and compilers. This book is just as self-referential as Scheme is. It is a book by MIT professors for an MIT class and is published by MIT Press. What works for a programming language doesn't work for a book.
The class this book is designed for is on introductory programming. But don't expect to learn programming here. The authors have too many axes to grind to have time to worry about the best way to teach beginners about programming. They must point out that the C language suffers "defects" and that C programmers can be "reformed" by programming in Scheme. Every member of the MIT computer science department circa 1980 must show up somewhere in the footnotes, another distraction for the authors.
There is plenty of good computer science here, but you already have to be a computer scientist to appreciate it. And the Scheme language is itself wonderful. Just don't try to learn it here.
The teaching method used in the book is adding successive layers of abstraction. To the authors, the world beyond Cambridge, Massachusetts is nothing but a vague abstraction.

There are many things wrong with this book, but perhaps the worst is its shameless lying when the authors promise you profound knowledge of computer science and end up delivering a cheezy promotion of Scheme. They only concentrate on aspects of programming as it involves Scheme and don't make any effort to teach computer science as an art or as a science. They don't teach anything that's applicable in general, or will give you better understanding of the issues involved in writing good software. All they do is present trivial topics such as basic data structures and programming example, and it's all using Scheme. I ended up learning Scheme and nothing else.
There are plenty of other good books which cover the art of programming so generally that you'll find information useful in any programming project. For example: Cormen, Leiserson, Rivest "Introduction to algorithms", Knuth "The art of computer programming" (3 volumes) ... these are all highly regarded books. All I hear about SICP from students and professors alike is that they wish the book ceased to exist.
Don't listen to the others on this page...the book won't teach you to be a better programmer, and it won't teach you how to understand programs. It'll simply waste a lot of your time.

That's right, this book is plain boring, even for a CS major like myself. I did not learn anything except for Scheme syntax. Once you get that, the rest of the book is useless. This text is a half-baked attempt at algroithms and data structures, and of course, since it's tailored to scheme, I never found much use for these concepts later. In fact, once you start programming in a real language like C, you'll have to relearn all the concepts and see how they really work in the proper programming setting. On top of that, the writers make absolutely no attempt to be clear. Because no one thought of building iteration into scheme, you're stuck with a perposterous recursion overuse, complicating many simple algorithms, and confusing even the brightest students. Even my professor didn't like the book. It has the feel of a book written for no other reason than Abelson's self-gratification. If you value your time, avoid this book. Get instead the wonderful text by Cormen, Leiserson and Rivest : "Introduction to Algorithms"

-- for someone who never has to deal with industrial software. But there is greatness here, so let's start with that.

The book is entirely based on a Lisp dialect. That gives a very strong mathematical note to the whole text, where functions of functions arise early on. This book lays out an aggressive first course in programming, introducing valuable topics like lazy evaluation, logic programming, interpreters, and constraint propagation. These, of course, have many applications and even more implications; the base concepts are useful far beyond the case studies presented here. The students of this course also receive vivid demonstrations of the hazards of parallelism, and the merits of stateless functional programming in eliminating change-of-state race conditions.

Sorry, to say, I'm not a functional programmer. I use imperative languages (call them dys-functional if you must). So do 99.9% of all commercial software developers. They're stateful languages, and reflect the fact that the world has state. It may be elegant to move back and forth along the static, four-dimensional space-time trajectory of moving objects with respect to fixed ones. In practice, however, a car ramming a wall should not be considered a reversible event.

One must also note that the early versions of this book date to the 1980s, before object orientation became widespread. Even the later edition (1996) ignores the basics of OO practice, since they couldn't be captured in the version of Lisp favored here. Instead, examples (ex. p.189) propagate the pernicious practice of hand-coding polymorphism via switch statements or manual table management. I'm not an OO absolutist by any means. I'm painfully aware of its limits, and willing to recommend functional style when it solves specific problems. I am fully cognizant of the iron and silicon that lie under my program, however, and of the mutualism between hardware and software. In all the years I've been building software and hardware, I've never seen a "functional" computer. Sooner or later, all of them store bits - if nothing else, the functional program itself.

There's a lot of good in this book, including a great example of how to design a programming course for a brilliant novice. Believe me, the smart students can be harder to handle than the plodders (but worth it). This may outstrip the plodders, though. And, in the end, it teaches only Lisp - a language with negligible presence in the working world.

//wiredweird

There's no useful material here, whatever your level of sophistication. Beginners will find that Scheme, and the book's approach in general are confusing. Those who are advanced will find the text is full of bull, and a book like "Introduction to Algorithms" by Cormen et.al. will provide you with many more theoretical and practical topics alike, but it's advanced (and hence more interesting than SICP drivel). If you are a beginner, "C++ how to program" by Deitel will teach you all about object oriented and top down programming, plus you'll learn the C++, the most common language out there.
Whatever is presented, is of such poor quality, and so dry, I couldn't stay awake long enough to finish my assignments. You can learn how to be a good programmer from any computer science course or text, and there are only several sections about that in this book. If you are looking for interesting theoretical ideas, look for other texts, such as the ones mentioned above.
From what I've read, I get the impression this book was written in a rush, and with the purpose of cramming tons of nonsense and filler in just to have an excuse to present Scheme (a pathetic language). The authors claim to present a view of programming that's widely applicable, and state that top-down (i.e. procedural) programming is by far not the best way to think about programs abstractly. Well, they don't stick to their promise. They present a biased, one sided promotion of scheme as the best language out there. No attempt is made to make comparisons between functional languages like scheme and normal languages like C. The end result, you come out knowing scheme and a few boring applications of it, but can't apply any of it to real programming tasks. This proves this book is just a fancy concotion of some egghead professor who has no idea what happens in the real world. I found many explanations to be incoherent and contradictory. The whole approach is divorced from the computing practice. This is no 21 day book, in fact, you can spend 21 months on it and still not learn a thing, because there's nothing but worthless garbage here.